home *** CD-ROM | disk | FTP | other *** search
/ Aminet 8 / Aminet 8 (1995)(GTI - Schatztruhe)[!][Oct 1995].iso / Aminet / util / cli / WOIST.lha / WoIst / Source / WoIst.mod < prev   
Text File  |  1995-04-20  |  15KB  |  536 lines
  1. (**************************************************************************
  2.  
  3. :Remark.            Format: ein TAB in jeder 3. Spalte: ..tab..tab..tab..
  4.  
  5.  
  6. :Program.        WoIst
  7.  
  8. :Contents.        Sucht nach einem anzugebenden Eintrag rekursiv im aktuellen
  9. :Contents.        Verzeichnis. Nur im CLI zu verwenden.
  10.  
  11. :Bugs.            "Shit happens." (Murphy)
  12.  
  13.  
  14. :Copyright.        Freeware---you may copy and use it, but all rights remain
  15. :Copyright.        at the author
  16.  
  17. :Author.            Thomas Ansorge
  18.  
  19. :Address.        Dinkelackerring 55, 67435 Neustadt, Deutschland, Europa
  20.  
  21.  
  22. :Language.        Modula-2
  23.  
  24. :Translator.    M2Amiga V4.3 (deutsch)
  25.  
  26.  
  27. :History.        1.0 vom 20.02.1994
  28.  
  29. :History.        2.0 as of 19-Apr-1995:
  30. :History.            - forgotton $VER-String included
  31. :History.            - changed from module Arguments to DosL.RDArgs
  32. :History.            - changed from module Heap to ExecL.AllocMem
  33. :History.            - changed from module Terminal to DosL.Write
  34. :History.            - new templates: NODIRS, NOFILES, NAMESONLY included
  35. :History.            - new templates: SINCE, UPTO, TIME
  36. :History.            - PrintFault (IoErr, ADR (ver_str)) added
  37.  
  38.  
  39. **************************************************************************)
  40.  
  41.  
  42. MODULE WoIst;
  43.  
  44. FROM Arts IMPORT Assert, returnVal, Terminate, thisTask, wbStarted;
  45.  
  46. FROM ASCII IMPORT lf, nul;
  47.  
  48. FROM Conversions IMPORT ValToStr;
  49.  
  50. FROM DosD IMPORT accessRead, ctrlC, Date, DateFormat, DateTime, DateTimeFlags, DateTimeFlagSet, DateTimePtr, dosFib, error, fail, FileInfoBlock, FileInfoBlockPtr, FileLock, FileLockPtr, ProcessPtr, RDArgsPtr, warn;
  51.  
  52. FROM DosL IMPORT AllocDosObject, CompareDates, CurrentDir, dosVersion, Examine, ExNext, FreeArgs, FreeDosObject, IoErr, Lock, MatchPatternNoCase, NameFromLock, Output, ParsePatternNoCase, PrintFault, ReadArgs, StrToDate, UnLock, Write;
  53.  
  54. FROM ExecD IMPORT MemReqs, MemReqSet;
  55.  
  56. FROM ExecL IMPORT AllocMem, FreeMem, SetSignal;
  57.  
  58. FROM LocaleD IMPORT CatalogPtr;
  59.  
  60. FROM LocaleL IMPORT CloseCatalog, GetCatalogStr, OpenCatalogA;
  61.  
  62. FROM String IMPORT Length;
  63.  
  64. FROM SYSTEM IMPORT ADDRESS, ADR, CAST, LONGSET;
  65.  
  66. (* --------------------------------------------------------------------- *)
  67.  
  68. CONST
  69.     prog_str = "WoIst 2.0/";
  70.     date_str = "(19.04.95)";
  71.  
  72.     (*$ IF M68881 OR M68040 *)
  73.         ver_str = prog_str + "68020+FPU " + date_str;
  74.     (*$ ELSIF M68020 *)
  75.         ver_str = prog_str + "68020 " + date_str;
  76.     (*$ ELSIF M68010 *)
  77.         ver_str = prog_str + "68010 " + date_str;
  78.     (*$ ELSE *)
  79.         ver_str = prog_str + "68000 " + date_str;
  80.     (*$ ENDIF *)
  81.     
  82.     ver_ptr = ADR ("$VER: " + ver_str);
  83.  
  84. CONST
  85.     dosMinVersion = 37;
  86.     patternBufferStep = 512;
  87.  
  88.     (* korrespondiert zu ArgsRecord *)
  89.     template = "PATTERN/A,ND=NODIRS/S,NF=NOFILES/S,NO=NAMESONLY/S,SINCE/K,UPTO/K,TIME/K";
  90.  
  91.     woistCatName = "WoIst.catalog";
  92.  
  93.     (* obsolete
  94.     copyrightNr = 0;
  95.     usageNr = 1;
  96.     *)
  97.  
  98.     lookFor = "WoIst: looking for \"";
  99.     lookForNr = 2;
  100.  
  101.     foundBeforeDir = "WoIst: found directory \"\e[1m";
  102.     foundBeforeDirNr = 3;
  103.  
  104.     foundBeforeFile = "WoIst: found   file    \"\e[1m";
  105.     foundBeforeFileNr = 4;
  106.  
  107.     foundAfter = "\e[0m\".";
  108.     foundAfterNr = 5;
  109.  
  110.     nothingElseFound = "WoIst: nothing (else) found.";
  111.     nothingElseFoundNr = 6;
  112.  
  113.     found_dirs_str = " directory (-ies) found!";
  114.     found_dirs_id = 7;
  115.  
  116.     found_files_str = " file (-s) found!";
  117.     found_files_id = 8;
  118.  
  119.     total_str = "total:";
  120.     total_id = 9;
  121.  
  122.     bytes_str = "bytes";
  123.     bytes_id = 10;
  124.  
  125.     blocks_str = "blocks";
  126.     blocks_id = 11;
  127.     
  128.     upto_since_str = "Warning: UPTO will be ignored if SINCE is given!";
  129.     upto_since_id = 12;
  130.  
  131.     time_ignored_str = "Warning: TIME without SINCE or UPTO will be ignored!";
  132.     time_ignored_id = 13;
  133.  
  134.     dosCatName = "sys/dos.catalog";
  135.     breakStrNr = 304;
  136.     breakStr = "*** Break";
  137.  
  138. TYPE
  139.     ArgsRecord = RECORD
  140.         pattern_ptr: ADDRESS;
  141.         no_dirs: LONGINT;
  142.         no_files: LONGINT;
  143.         names_only: LONGINT;
  144.         since: ADDRESS;
  145.         upto: ADDRESS;
  146.         time: ADDRESS;
  147.     END; (* RECORD ArgsRecord *)
  148.  
  149.     PatternBufferPtr = ADDRESS;
  150.  
  151.     Str255Ptr = POINTER TO ARRAY [0..255] OF CHAR;
  152.  
  153. VAR
  154.     (* Pointer *)
  155.     dosCatPtr: CatalogPtr;
  156.     patternBuffer: PatternBufferPtr;
  157.     rdargs_ptr: RDArgsPtr;
  158.     woistCatPtr: CatalogPtr;
  159.  
  160.     (* other 32bit stuff *)
  161.     args: ArgsRecord;
  162.     found_blocks: LONGCARD;
  163.     found_bytes: LONGCARD;
  164.     found_dirs: LONGCARD;
  165.     found_files: LONGCARD;
  166.     patternBufferSize: LONGCARD;
  167.  
  168.     (* others *)
  169.     date_time: DateTime;
  170.     date_flag: BOOLEAN;
  171.  
  172. (* --------------------------------------------------------------------- *)
  173.  
  174. PROCEDURE WriteLn (); FORWARD;
  175.  
  176. PROCEDURE WriteString (str_ptr: ADDRESS); FORWARD;
  177.  
  178. (* --------------------------------------------------------------------- *)
  179.  
  180. PROCEDURE GetDate (date_str_ptr: ADDRESS; VAR date_time: DateTime; time_str_ptr: ADDRESS): BOOLEAN;
  181.  
  182.     (* date_str_ptr ist garantiert # NIL *)
  183.  
  184.     BEGIN (* Funktion GetDate *)
  185.         WITH date_time DO
  186.             format := formatDOS;
  187.             flags := DateTimeFlagSet {};
  188.             strDate := date_str_ptr;
  189.             strTime := time_str_ptr;
  190.         END; (* WITH date_time DO *)
  191.  
  192.         IF StrToDate (ADR (date_time)) = 0 THEN
  193.             IF PrintFault (IoErr (), ADR ("SINCE/UPTO/TIME")) THEN END;
  194.             
  195.             returnVal := fail;
  196.             Terminate ();
  197.         END; (* IF StrToDate (ADR (date_time)) = 0 *)
  198.         
  199.         RETURN TRUE;
  200.     END GetDate; (* Funktion GetDate *)
  201.  
  202. (* --------------------------------------------------------------------- *)
  203.  
  204. PROCEDURE Search (dirLockPtr: FileLockPtr; buffer: PatternBufferPtr; date_flag: BOOLEAN; dos_date: Date);
  205.  
  206.     VAR
  207.         infoBlockPtr: FileInfoBlockPtr;
  208.         lockPtr     : FileLockPtr;
  209.         oldLockPtr  : FileLockPtr;
  210.  
  211.     (* ------------------------------------------------------------------ *)
  212.  
  213.     PROCEDURE WriteFound (
  214.         dirLockPtr  : FileLockPtr;
  215.         infoBlockPtr: FileInfoBlockPtr);
  216.  
  217.         (* Eigene Prozedur, da Search rekursiv und name ziemlich groß ist. *)
  218.  
  219.         TYPE
  220.             NameStr = ARRAY [0..255] OF CHAR;
  221.  
  222.         VAR
  223.             name: NameStr;
  224.  
  225.         (* --------------------------------------------------------------- *)
  226.  
  227.         BEGIN (* Prozedur WriteFound *)
  228.             IF NameFromLock (dirLockPtr, ADR (name), SIZE (name)) THEN
  229.                 IF infoBlockPtr^.dirEntryType > 0 THEN
  230.                     (* Verzeichnis *)
  231.  
  232.                     IF args.no_dirs = 0 THEN
  233.                         IF args.names_only = 0 THEN
  234.                             WriteString (GetCatalogStr (woistCatPtr, foundBeforeDirNr, ADR (foundBeforeDir)));
  235.                         END; (* IF args.names_only = 0 *)
  236.  
  237.                         WriteString (ADR (name));
  238.  
  239.                         IF name [Length (name) - 1] # ":" THEN
  240.                             WriteString (ADR ("/" + nul));
  241.                         END (* IF name [Length (name)] # ":" *);
  242.  
  243.                         WriteString (ADR (infoBlockPtr^.fileName));
  244.                         WriteString (ADR ("/"+nul));
  245.  
  246.                         IF args.names_only = 0 THEN
  247.                             WriteString (GetCatalogStr (woistCatPtr, foundAfterNr, ADR (foundAfter)));
  248.                         END; (* IF args.names_only = 0 *)
  249.  
  250.                         WriteLn ();
  251.  
  252.                         INC (found_dirs);
  253.                     END; (* IF args.no_dirs = 0 *)
  254.  
  255.                 ELSE (* IF infoBlockPtr^.dirEntryType > 0 *)
  256.                     (* Datei *)
  257.  
  258.                     IF args.no_files = 0 THEN
  259.                         IF args.names_only = 0 THEN
  260.                             WriteString (GetCatalogStr (woistCatPtr, foundBeforeFileNr, ADR (foundBeforeFile)));
  261.                         END; (* IF args.names_only = 0 *)
  262.  
  263.                         WriteString (ADR (name));
  264.  
  265.                         IF name [Length (name) - 1] # ":" THEN
  266.                             WriteString (ADR ("/" + nul));
  267.                         END (* IF name [Length (name)] # ":" *);
  268.  
  269.                         WriteString (ADR (infoBlockPtr^.fileName));
  270.  
  271.                         IF args.names_only = 0 THEN
  272.                             WriteString (GetCatalogStr (woistCatPtr, foundAfterNr, ADR (foundAfter)));
  273.                         END; (* IF args.names_only = 0 *)
  274.  
  275.                         WriteLn ();
  276.  
  277.                         INC (found_files);
  278.                         found_bytes := found_bytes + LONGCARD (infoBlockPtr^.size);
  279.                         found_blocks := found_blocks + LONGCARD (infoBlockPtr^.numBlocks);
  280.                     END; (* IF args.no_files = 0 *)
  281.                 END (* IF infoBlockPtr^.dirEntryType > 0 *);
  282.             END (* IF NameFromLock ( *);
  283.         END WriteFound (* Prozedur *);
  284.  
  285.     (* ------------------------------------------------------------------ *)
  286.  
  287.     BEGIN (* Prozedur Search *)
  288.  
  289.     infoBlockPtr := AllocDosObject (dosFib, NIL);
  290.  
  291.     IF infoBlockPtr = NIL THEN
  292.         WriteString (ADR ("WoIst: Error: AllocDosObject () (AllocMemory ()?) failed!"));
  293.         WriteLn ();
  294.  
  295.         RETURN; (* Locks freigeben... *)
  296.     END (* IF infoBlockPtr = NIL *);
  297.  
  298.     oldLockPtr := CurrentDir (dirLockPtr);
  299.  
  300.     LOOP
  301.         IF Examine (dirLockPtr, infoBlockPtr) THEN
  302.             WHILE ExNext (dirLockPtr, infoBlockPtr) DO
  303.                 IF MatchPatternNoCase (buffer, ADR (infoBlockPtr^.fileName)) THEN
  304.                     IF date_flag THEN
  305.                         IF args.since # NIL THEN
  306.                             IF CompareDates (ADR (dos_date), ADR (infoBlockPtr^.date)) >= 0 THEN
  307.                                 WriteFound (dirLockPtr, infoBlockPtr);
  308.                             END; (* IF CompareDates (ADR (dos_date), ADR (infoBlockPtr^.date)) >= 0 *)
  309.  
  310.                         ELSE (* IF args.since # NIL *)
  311.                             IF CompareDates (ADR (dos_date), ADR (infoBlockPtr^.date)) <= 0 THEN
  312.                                 WriteFound (dirLockPtr, infoBlockPtr);
  313.                             END; (* IF CompareDates (ADR (dos_date), ADR (infoBlockPtr^.date)) <= 0 *)
  314.                         END; (* IF args.since # NIL ELSE *)
  315.  
  316.                     ELSE (* IF date_flag *)
  317.                         WriteFound (dirLockPtr, infoBlockPtr);
  318.                     END; (* IF date_flag ELSE *)
  319.                 END (* IF MatchPatternNoCase *);
  320.  
  321.                 IF infoBlockPtr^.dirEntryType > 0 THEN
  322.                     lockPtr := Lock (ADR (infoBlockPtr^.fileName), accessRead);
  323.  
  324.                     IF lockPtr # NIL THEN
  325.                         Search (lockPtr, buffer, date_flag, dos_date);
  326.  
  327.                         UnLock (lockPtr);
  328.                         lockPtr := NIL;
  329.                     END (* IF lockPtr # NIL *);
  330.                 END (* IF infoBlockPtr^.dirEntryType > 0 *);
  331.  
  332.                 IF ctrlC IN SetSignal (LONGSET {}, LONGSET {}) THEN
  333.                     EXIT (* LOOP *);
  334.                 END (* IF ctrlC IN SetSignal (LONGSET {}, LONGSET {}) *);
  335.             END (* WHILE ExNext (dirLockPtr, infoBlockPtr) *);
  336.         END (* IF Examine (dirLockPtr, infoBlockPtr) *);
  337.  
  338.         EXIT (* LOOP *);
  339.     END (* LOOP *);
  340.  
  341.     oldLockPtr := CurrentDir (oldLockPtr);
  342.  
  343.     FreeDosObject (dosFib, infoBlockPtr);
  344. END Search (* Prozedur *);
  345.  
  346. (* --------------------------------------------------------------------- *)
  347.  
  348. PROCEDURE WriteLn ();
  349.  
  350.     CONST
  351.         lf_str = lf + nul;
  352.  
  353.     BEGIN (* Prozedur WriteLn *)
  354.         WriteString (ADR (lf_str));
  355.     END WriteLn; (* Prozedur *)
  356.  
  357. (* --------------------------------------------------------------------- *)
  358.  
  359. PROCEDURE WriteString (str_ptr: ADDRESS);
  360.  
  361.     BEGIN (* Prozedur WriteString *)
  362.         IF Output () # NIL THEN
  363.             (* Bug: -1 statt Length (...) funktioniert nicht mit der Commandline-History der WShell! *)
  364.             IF 0 # Write (Output (), str_ptr, Length (CAST (Str255Ptr, str_ptr)^)) THEN END;
  365.         END; (* IF Output () # NIL *)
  366.     END WriteString; (* Prozedur *)
  367.  
  368. (* --------------------------------------------------------------------- *)
  369.  
  370. PROCEDURE WriteNum (l: LONGINT);
  371.  
  372.     VAR
  373.         (* 32bit stuff *)
  374.         str: ARRAY [0..11] OF CHAR;
  375.  
  376.         (* other stuff *)
  377.         err: BOOLEAN;
  378.  
  379.     BEGIN (* Prozedur WriteNum *)
  380.         ValToStr (l, FALSE, str, 10, 1, " ", err);
  381.  
  382.         IF err THEN
  383.             str := "(???)";
  384.         END; (* IF err *)
  385.  
  386.         WriteString (ADR (str));
  387.     END WriteNum; (* Prozedur *)
  388.  
  389. (* --------------------------------------------------------------------- *)
  390. (* --------------------------------------------------------------------- *)
  391.  
  392. BEGIN (* MODULE WoIst *)
  393.     Assert (NOT wbStarted, ADR ("CLI!"));
  394.  
  395.     IF dosVersion < dosMinVersion THEN
  396.         WriteString (ADR ("WhereIs: Error: You need Kickstart 2.04 and Workbench 2.1 or newer!"));
  397.         WriteLn ();
  398.  
  399.         returnVal := fail;
  400.         Terminate ();
  401.     END (* IF dosVersion < dosMinVersion *);
  402.  
  403.     woistCatPtr := OpenCatalogA (NIL, ADR (woistCatName), NIL);
  404.  
  405.     (* Pattern bearbeiten *)
  406.  
  407.     rdargs_ptr := ReadArgs (ADR (template), ADR (args), NIL);
  408.  
  409.     IF rdargs_ptr = NIL THEN
  410.         IF PrintFault (IoErr (), NIL) THEN END;
  411.         
  412.         returnVal := fail;
  413.         Terminate ();
  414.     END; (* IF rdargs_ptr = NIL *)
  415.  
  416.     WriteLn ();
  417.  
  418.     (* Template zum Suchen: *)
  419.  
  420.     patternBufferSize := 2;
  421.  
  422.     REPEAT
  423.         IF patternBuffer # NIL THEN
  424.             FreeMem (patternBuffer, patternBufferSize);
  425.             patternBuffer := NIL;
  426.         END (* IF patternBuffer # NIL *);
  427.  
  428.         INC (patternBufferSize, patternBufferStep);
  429.  
  430.         patternBuffer := AllocMem (patternBufferSize, MemReqSet {public, memClear});
  431.     UNTIL (patternBuffer = NIL) OR (ParsePatternNoCase (args.pattern_ptr, patternBuffer, patternBufferSize) # -1);
  432.  
  433.     (* evt. SINCE, UPTO: *)
  434.  
  435.     date_flag := FALSE;
  436.  
  437.     IF args.since # NIL THEN
  438.         IF args.time # NIL THEN
  439.             date_flag := GetDate (args.since, date_time, args.time);
  440.  
  441.         ELSE (* IF args.time # NIL *)
  442.             date_flag := GetDate (args.since, date_time, ADR ("00:00:00"));
  443.         END; (* IF args.time # NIL ELSE *)
  444.  
  445.         IF args.upto # NIL THEN
  446.             WriteString (GetCatalogStr (woistCatPtr, upto_since_id, ADR (upto_since_str)));
  447.             WriteLn ();
  448.  
  449.             returnVal := warn;
  450.         END; (* IF args.upto # NIL *)
  451.  
  452.     ELSIF args.upto # NIL THEN
  453.         IF args.time # NIL THEN
  454.             date_flag := GetDate (args.upto, date_time, args.time);
  455.  
  456.         ELSE (* IF args.time # NIL *)
  457.             date_flag := GetDate (args.upto, date_time, ADR ("23:59:59"));
  458.         END; (* IF args.time # NIL ELSE *)
  459.  
  460.     ELSIF args.time # NIL THEN
  461.         WriteString (GetCatalogStr (woistCatPtr, time_ignored_id, ADR (time_ignored_str)));
  462.         WriteLn ();
  463.         
  464.         returnVal := warn;
  465.     END; (* ELSIF args.time # NIL *)
  466.  
  467.     (* suchen *)
  468.  
  469.     IF args.names_only = 0 THEN
  470.         WriteLn ();
  471.         WriteString (GetCatalogStr (woistCatPtr, lookForNr, ADR (lookFor)));
  472.         WriteString (args.pattern_ptr);
  473.         WriteString (ADR ("\"..."));
  474.         WriteLn ();
  475.         WriteLn ();
  476.     END; (* IF args.names_only = 0 *)
  477.  
  478.     IF (args.no_files = 0) OR (args.no_dirs = 0) THEN
  479.         Search (CAST (ProcessPtr, thisTask)^.currentDir, patternBuffer, date_flag, date_time.date);
  480.     END; (* IF (args.no_files = 0) OR (args.no_dirs = 0) *)
  481.  
  482.     IF args.names_only = 0 THEN
  483.         WriteLn ();
  484.     END; (* IF args.names_only = 0 *)
  485.  
  486.     IF ctrlC IN SetSignal (LONGSET {}, LONGSET {}) THEN
  487.         dosCatPtr := OpenCatalogA (NIL, ADR (dosCatName), NIL);
  488.         WriteString (GetCatalogStr (dosCatPtr, breakStrNr, ADR (breakStr)));
  489.         CloseCatalog (dosCatPtr);
  490.  
  491.     ELSE (* IF ctrlC IN SetSignal (LONGSET {}, LONGSET {}) *)
  492.         IF args.names_only = 0 THEN
  493.             WriteString (GetCatalogStr (woistCatPtr, nothingElseFoundNr, ADR (nothingElseFound)));
  494.         END; (* IF args.names_only = 0 *)
  495.     END (* IF ctrlC IN SetSignal (LONGSET {}, LONGSET {}) *);
  496.  
  497.     IF args.names_only = 0 THEN
  498.         WriteLn ();
  499.         WriteLn ();
  500.  
  501.         WriteString (GetCatalogStr (woistCatPtr, total_id, ADR (total_str)));
  502.         WriteLn ();
  503.  
  504.         WriteNum (found_dirs);
  505.         WriteString (GetCatalogStr (woistCatPtr, found_dirs_id, ADR (found_dirs_str)));
  506.         WriteLn ();
  507.  
  508.         WriteNum (found_files);
  509.         WriteString (GetCatalogStr (woistCatPtr, found_files_id, ADR (found_files_str)));
  510.         WriteString (ADR (" ("));
  511.         WriteNum (found_bytes);
  512.         WriteString (ADR (" \o"));
  513.         WriteString (GetCatalogStr (woistCatPtr, bytes_id, ADR (bytes_str)));
  514.         WriteString (ADR ("/\o"));
  515.         WriteNum (found_blocks);
  516.         WriteString (ADR (" \o"));
  517.         WriteString (GetCatalogStr (woistCatPtr, blocks_id, ADR (blocks_str)));
  518.         WriteString (ADR (")\o"));
  519.         WriteLn ();
  520.     END; (* IF args.names_only = 0 *)
  521.  
  522.     CLOSE; (* ----------------------------------------------------------- *)
  523.  
  524.     IF rdargs_ptr # NIL THEN
  525.         FreeArgs (rdargs_ptr);
  526.         rdargs_ptr := NIL;
  527.     END; (* IF rdargs_ptr # NIL *)
  528.  
  529.     IF patternBuffer # NIL THEN
  530.         FreeMem (patternBuffer, patternBufferSize);
  531.         patternBuffer := NIL;
  532.     END (* IF patternBuffer # NIL *);
  533.  
  534.     CloseCatalog (woistCatPtr);
  535. END WoIst (* MODULE *).
  536.